home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / ada / gnat1793.zip / features next >
Text File  |  1994-06-22  |  14KB  |  371 lines
  1. GNAT IMPLEMENTED FEATURES LIST
  2. Current as of 5/10/94
  3.  
  4. Here is the list of implemented and not implemented features. A more precise
  5. description of the GNAT system is provided in the file 'gnat-intro', which is
  6. part of the GNAT distribution.
  7.  
  8. Features added since GNAT version 1.78
  9. =======================================================================
  10.    The list of features has been reorganized into one list according
  11.    to the reference manual. Things listed are implemented unless specifically
  12.    listed as not being implemented.
  13.  
  14.    Some limited tasking on the Sparc SunOS version only. OS/2 version to 
  15.    follow in a few weeks. (See more detailed list of tasking features below)
  16.  
  17.    More complete documentation of cross referencer (see gnat-intro for details)
  18.  
  19.    access discriminants
  20.    derived enumeration types (exception from type Character)
  21.  
  22.    gnatsplit tool --  to deal with files containing several compilation units.
  23.  
  24.    gkrunch utility
  25.       8 character file names for RTL files to help GNAT on DOS and OS/2
  26.       running under the FAT.
  27.  
  28.    Generic Renaming
  29.  
  30.    Min and Max attributes
  31.  
  32.    Intrinsic Functions (see section in gnat-intro for more details)
  33.  
  34.    String Handling
  35.       The Package Strings
  36.       The Package Strings.Maps
  37.       Fixed-Length String Handling
  38.       Bounded-Length String Handling
  39.       Unbounded-Length String Handling
  40.       String-Handling Sets and Mappings
  41.  
  42. =======================================================================
  43. Status of Features
  44. ------------------
  45.  
  46. The parser is a full Ada9X parser, which implements the Ada 9X language
  47. as defined by version 4.0 of the Draft International Standard. Semantic
  48. analysis and code generation are in constant evolution.
  49.  
  50.   2. Lexical Elements
  51.      2.1 Character Set
  52.      2.2 Lexical Elements, Separators, and Delimiters
  53.      2.3 Identifiers
  54.      2.4 Numeric Literals
  55.          2.4.1 Decimal Literals
  56.          2.4.2 Based Literals
  57.      2.5 Character Literals
  58.      2.6 String Literals
  59.      2.7 Comments
  60.      2.8 Pragmas
  61.          see Appendix B listing for status of Pragmas
  62.      2.9 Reserved Words
  63.  
  64.   3. Declarations and Types
  65.   3.1 Declarations
  66.   3.2 Types and Subtypes
  67.       3.2.1 Type Declarations
  68.       3.2.2 Subtype Declarations
  69.       3.3 Objects and Named Numbers
  70.           3.3.1 Object Declarations
  71.           3.3.2 Number Declarations
  72.       3.4 Derived types and Classes
  73.           3.4.1 Derivation Classes
  74.           Derived types from private types (not implemented yet)
  75.       3.5 Scalar Types
  76.            Attribute 'Base 'Min 'Max
  77.           3.5.1 Enumeration Types
  78.              attributes (first, last, range, pos, val, image)
  79.           3.5.2 Character Types
  80.               attributes (first, last, range, pos, val, image)
  81.           3.5.3 Boolean Types
  82.           3.5.4 Integer Types
  83.               attributes (first, last, range, pos, val, image)
  84.               Modular Types
  85.           3.5.7 Floating Point Types
  86.           3.5.8 Operations of Floating Point Types
  87.               attributes -- see the list below attached with Appendix A
  88.    
  89.           3.5.9 Fixed Point Types                (not implemented yet)
  90.           3.5.10 Operations of Fixed Point Types (not implemented yet)
  91.  
  92.       3.6 Array Types
  93.           3.6.1 Index Constraints and Discrete Ranges
  94.           3.6.2 Operations of Array Types
  95.                 attributes first, last, range, length
  96.           3.6.3 String Types
  97.    
  98.       3.7 Discriminants
  99.           3.7.1 Discriminant Constraints
  100.           3.7.2 Operations of Discriminanted Types
  101.    
  102.       3.8 Record types
  103.           3.8.1 Variant Parts and Discrete Choices
  104.    
  105.        3.9 Tagged Types and Type Extensions
  106.           3.9.1 Type Extensions
  107.           3.9.2 Dispatching Operations and Subprograms
  108.           3.9.3 Abstract Types and Subprograms
  109.                 attribute 'Class
  110.    
  111.        3.10 Access Types
  112.           3.10.1 Incomplete Type Declarations
  113.           3.10.2 Operations of Access Types
  114.                  Access to subprograms
  115.                   attribute 'Access
  116.   4. Names and Expressions
  117.      4.1 Names
  118.          4.1.1 Indexed Components
  119.          4.1.2 Slices
  120.          4.1.3 Selected Components
  121.          4.2 Literals
  122.      4.3 Aggregates
  123.          4.3.1 Record Aggregates
  124.            aggregates for tagged types (not implemented yet)
  125.  
  126.          4.3.3 Array Aggregates
  127.      Exponentiation
  128.      Expressions (all forms)
  129.             static and dynamic concatenation
  130.          type conversions  (except array conversions)
  131.          membership tests, conversion with class-wide types
  132.     
  133.    5. Statements
  134.       5.1 Simple and Compound Statements - Sequences of Statements
  135.       5.2 Assignment Statements
  136.       5.3 If Statements
  137.       5.4 Case Statements
  138.       5.5 Loop Statements
  139.       5.6 Block Statements
  140.       5.7 Exit Statements
  141.       5.8 Goto Statements
  142.     
  143.    6. Subprograms
  144.       6.1 Subprogram Declarations
  145.       6.2 Formal Parameter Modes
  146.       6.3 Subprogram Bodies
  147.           (6.3.1 No Conformance Rules yet)
  148.           (6.3.2 No Inline Expansion of Subprograms yet)
  149.       6.4 Subprogram Calls
  150.           6.4.1 Parameter Associations
  151.       6.5 Return Statements
  152.       6.6 Overloading of Operators
  153.      
  154.    7. Packages
  155.       7.1 Package Specifications and Declarations
  156.       7.2 Package Bodies
  157.       7.3 Private Types (no private extension yet)
  158.       7.3.1 Operations of Private Types
  159.       7.4 Deferred Constants
  160.       7.5 Limited Types
  161.       7.6 User-Defined Assignment and Finalization (simple cases)
  162.           7.6.1 Completion and Finalization (simple cases)
  163.  
  164.    8. Visibility Rules
  165.       8.1 Declarative Region
  166.       8.2 Scope of Declarations
  167.       8.3 Visibility
  168.       8.4 Use Clauses
  169.       8.5 Renaming Declarations
  170.           8.5.1 Object Renaming Declarations
  171.           8.5.2 Exception Renaming Declarations
  172.           8.5.3 Package Renaming Declarations
  173.           8.5.4 Subprogram Renaming Declarations
  174.           8.5.5 Generic Renaming Declarations
  175.       8.6 The Context of Overload Resolution
  176.  
  177.    9. Tasks and Synchronization (Currently on Sparc SunOS verion only)
  178.       9.1 Task Units and Task Objects (and access to task)
  179.       9.2 Task Execution - Task Activation
  180.       9.3 Task Dependence - Termination of Tasks
  181.       9.4 Protected Units and Protected Objects (not implemented)
  182.       9.5 Intertask Communication
  183.           9.5.1 Protected Subprograms (not implemented)
  184.           9.5.2 Entries and Accept Statements (and entry families)
  185.           9.5.3 Entry Calls
  186.           9.5.4 Requeue Statements (not implemented)
  187.       9.6 Delay Statements, Duration, and Time (not implemented)
  188.       9.7 Select Statements
  189.           9.7.1 Selective Accept
  190.           9.7.2 Timed Entry Calls (not implemented)
  191.           9.7.3 Conditional Entry Calls
  192.           9.7.4 Asynchronous Transfer of Control (not implemented)
  193.       9.8 Abort of a Task - Abort of a Sequence of Statements (not implemented)
  194.       9.9 Task and Entry Attributes
  195.           Callable, Count,  Terminated (not implemented)
  196.       9.10 Shared Variables (not implemented)
  197.  
  198.       package Calendar (not implemented yet)
  199.  
  200.    10. Program Structure and Compilation Issues
  201.        10.1 Separate Compilation
  202.            10.1.1 Compilation Units - Library Units
  203.                   (including child units)
  204.            10.1.2 Context Clauses - With Clauses
  205.            10.1.3 Subunits of Compilation Units
  206.            10.1.4 The Compilation Process
  207.            10.1.5 Pragmas and Compilations
  208.            10.1.6 Environment-Level Visibility Rules
  209.         10.2 Program Execution
  210.            10.2.1 Elaboration Control
  211.               (pragmas Elaborate and Elaborate_All)
  212.  
  213.     11. Exceptions
  214.         11.1 Exception Declarations
  215.         11.2 Exception Handlers
  216.         11.3 Raise Statements
  217.         11.4 Exception Handling
  218.         11.5 Suppressing Checks
  219.         11.6 Exceptions and Optimization
  220.  
  221.         limited constraint checking on integer/enumeration types under the
  222.         following catagories:
  223.           Index Checks
  224.           Access Checks
  225.           Range Checks
  226.             Initial values in object declarations.
  227.             Assignment
  228.             parameter passing of IN parameters
  229.             type conversions
  230.  
  231.          No constraint checking on floating point types or modular types.
  232.  
  233.     12. Generic Units
  234.         12.1 Ge